What does this PR do?

Starting from v3, we are changing the way attributes are handled to improve safety, consistency and compatibility with native SDKs, and to support more attribute typesl

What’s New

• Unsupported values (functions, symbols, non-finite numbers, etc.) are automatically dropped, with warnings, to prevent crashes in native SDKs.
• Common types such as Date, Error, and Map are properly serialized
• Nested objects are automatically flattened into dot syntax (a.b.c = value), matching the format expected by native SDKs and avoiding ambiguous outcomes.
• Custom encoders can be registered by users to support domain-specific types.
• Primitives and arrays at the root are wrapped under a context key to maintain schema consistency.

Motivation

In React Native, it’s common for developers to pass complex objects as attributes (e.g. partial or full Redux/Zustand state, raw Error objects). These may contain unserializable values that would break serialization. While ideally users should only pass clean dictionaries of encodable values, in practice they expect the SDK to handle arbitrary objects to some extent.

This change ensures:

• Everything passed from JS to native is safe and JSON-serializable
• Flattening happens in JS, so users don’t need to handle dot syntax manually (which is not idiomatic in React Native), and we don't have to rely on the native SDKs either
• Ambiguities between nested objects and dot-syntax keys are avoided

Example Transformations

• "foo" → { context: "foo" }

• { user: { profile: { name: "Alice" } } } → { "user.profile.name": "Alice" }

• new Error("Boom") → { "context.name": "Error", "context.message": "Boom", "context.stack": "...", ... }

• new Map([["k1", 1], ["k2", "v2"]]) →

  {
    "context": [
      { "key": "k1", "keyType": "string", "value": 1 },
      { "key": "k2", "keyType": "string", "value": "v2" }
    ]
  }

• Unsupported values like Symbol("x") or () => {} → {} (dropped with warning)

Benchmarks

• Flat/nested objects: ~1M ops/sec
• Deeply nested objects (20+ levels): ~233k ops/sec
• Maps with mixed keys: ~405k ops/sec
• Arrays of objects: ~28k–33k ops/sec (expectedly slower due to recursion)